home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 4 / FM Towns Free Software Collection 4 - Disc 1.iso / t_os / tie / src / cons.c < prev    next >
C/C++ Source or Header  |  1991-10-18  |  20KB  |  828 lines
  1. /******************************
  2.  *      Consol Low I/O        *
  3.  ******************************/
  4. #include    <fmc.h>
  5. #include    "oaklib.h"
  6. #include    "config.h"
  7. #include    "edit.h"
  8.  
  9. #define FSIZE   16      /*  フォント・サイズ  */
  10. #define PIX_BYTE 1      /* 画面モ－ドにより変化 16色=1 256色=1 32K色=2 */
  11.  
  12. #define FNT_X   8
  13. #define FNT_Y   16
  14.  
  15. #define LINE_MAX    256
  16.  
  17.  
  18. #define OPEN    wp->opened
  19. #undef TOP_X
  20. #undef TOP_Y
  21. #define TOP_X   wp->top_x
  22. #define TOP_Y   wp->top_y
  23. #define BTM_X   wp->btm_x
  24. #define BTM_Y   wp->btm_y
  25. #define SIZ_X   wp->siz_x
  26. #define CUR_X   (*wp->cur_x)
  27. #define _CUR_X  wp->cur_x
  28. #define CUR_POS wp->cur_pos
  29. #define CUT_X   wp->cut_x
  30. #define CUT_POS wp->cut_pos
  31. #define COL_CHR wp->chr_col
  32. #define BAK_CHR wp->chr_bak
  33. #define CUR_COL wp->cur_col
  34. #define COL_BAK wp->bak_col
  35. #define KAN_COD wp->kan_cod
  36. #define EDITBUF wp->editbuf
  37. #define DSP_X   wp->dsp.x
  38. #define DSP_Y   wp->dsp.y
  39. #define DSP_LEN wp->dsp.len
  40. #define DSP_BUF wp->dsp.buf
  41.  
  42. static  WIND    act_wind = { FALSE,
  43.                             0,0, 0,0, 0, 0,0, -1,-1, 0,15,2,15, 0, 0,0,0 } ;
  44. static  WIND    *wp = &act_wind ;
  45.  
  46. static  int     bch = 0xFFFF ;
  47. static  u_int   bec = 0 ;
  48.  
  49. static  int     mos_x = -1, mos_y = -1 ;
  50.  
  51. static  char    tmpbuf[ 256 ] ;
  52. static  char    kan_mode[ 16 ] = "" ;
  53. static  char    cutbuf[ LINE_MAX ] ;
  54. static  char    ktype[ LINE_MAX ] ;
  55. static  char    linebuf[ LINE_MAX ] ;
  56. static  int     linelen = 0 ;
  57.  
  58.  
  59. void    keyflush( void )
  60. {
  61.     while( kbhit( OFF ) != 0 )
  62.         getch() ;
  63. }
  64.  
  65. #if 1
  66. int     kbhit( int open_check )
  67. {
  68.     static  u_char  matrix[16] ;
  69.     static  u_int   now_break = OFF, now_copy = OFF ;
  70.     static  u_int   last_break = OFF, last_copy = OFF ;
  71.  
  72.     if( open_check == ON && OPEN != TRUE )
  73.         return 0 ;
  74.  
  75.     last_break = now_break, last_copy = now_copy ;
  76.     KYB_matrix( (char *)matrix ) ;
  77.     now_break = ( ( matrix[15] ) & 0x10 ) != 0 ? ON : OFF ;
  78.     now_copy  = ( ( matrix[15] ) & 0x20 ) != 0 ? ON : OFF ;
  79.     if( last_break == ON && now_break == OFF )
  80.     {
  81.         bch = 0x8000, bec = 0x7C00 ;
  82.         return 1 ;
  83.     }
  84.     if( last_copy == ON && now_copy == OFF )
  85.     {
  86.         bch = 0x8000, bec = 0x7D00 ;
  87.         return 1 ;
  88.     }
  89.  
  90.     if( bch != 0xFFFF || ( bch = KAN_read( 1, &bec ) ) != 0xFFFF )
  91.         return 1 ;
  92.     else
  93.         return 0 ;
  94. }
  95. #else
  96. int     kbhit( int open_check )
  97. {
  98.     if( open_check == ON && OPEN != TRUE )
  99.         return 0 ;
  100.  
  101.     if( bch != 0xFFFF || ( bch = KAN_read( 1, &bec ) ) != 0xFFFF )
  102.         return 1 ;
  103.     else
  104.         return 0 ;
  105. }
  106. #endif
  107.  
  108. int     getch( void )
  109. {
  110.     int    ch ;
  111.  
  112.     do {
  113.         while( kbhit( OFF ) == 0 ) ;
  114.         ch = bch ;  bch = 0xFFFF ;
  115.     } while ( ch == 0 ) ;
  116.  
  117.     if( ( ch & 0xFF00 ) == 0x8000 )
  118.         ch = 0x8000 | ( bec >> 8 ) ;
  119.  
  120.     return ch ;
  121. }
  122.  
  123. void    typecheck( char type[], char buf[], int width )
  124. {
  125.     REGS    int     i ;
  126.  
  127.     for( i = 0 ; i < width && buf[i] != '\0' ; i ++ )
  128.     {
  129.         if( iskanji( buf[i] ) && iskanji2( buf[i+1] ) )
  130.         {
  131.             type[ i ] = IS_KANJI1 ;
  132.             type[i+1] = IS_KANJI2 ;
  133.             i ++ ;
  134.             continue ;
  135.         }
  136.         type[i] = IS_ANK ;
  137.     }
  138.     type[i] = IS_ANK ;
  139. }
  140.  
  141.  
  142. static  void    cur_dsp( int sw )
  143. {
  144.     static  int     pos ;
  145.     static  int     cpos ;
  146.     auto    char    para[8] ;
  147.     auto    int     TOPx = TOP_X ;
  148.  
  149.     if( ( TOPx % 2 ) == 1 )
  150.         TOPx -- ;
  151.  
  152.     if( sw == 0 )
  153.     {
  154.         pos = CUR_X * FNT_X + TOPx ;
  155.         if( CUT_X >= 0 )
  156.             cpos = CUT_X * FNT_X + TOPx ;
  157.     }
  158.  
  159.     EGB_writeMode( egbwork, 0x04 ) ;
  160.     EGB_paintMode( egbwork, 0x22 ) ;
  161.     EGB_color( egbwork, 0, CUR_COL ) ;
  162.     WORD(para+0) = pos ;
  163.     WORD(para+4) = pos + FNT_X - 1 ;
  164.     WORD(para+2) = ( CUT_POS >= 0 ) ? (DSP_Y+7) : (DSP_Y+14) ;
  165.     WORD(para+6) = ( CUT_POS >= 0 ) ? (DSP_Y+8) : (DSP_Y+15) ;
  166.     EGB_rectangle( egbwork, para ) ;
  167.  
  168.     if( CUT_POS >= 0 && CUT_POS < CUR_POS )
  169.     {
  170.         EGB_color( egbwork, 0, 15 ) ;
  171.         EGB_paintMode( egbwork, 0x22 ) ;
  172.         WORD(para+0) = cpos ;
  173.         WORD(para+2) = DSP_Y ;
  174.         WORD(para+4) = pos - 1 ;
  175.         WORD(para+6) = DSP_Y + 15 ;
  176.         EGB_rectangle( egbwork, para ) ;
  177.     }
  178.  
  179.     EGB_writeMode( egbwork, 0 ) ;
  180. }
  181.  
  182.  
  183. static  void    cflush( void )
  184. {
  185.     cur_dsp( 1 ) ;
  186.     if( DSP_LEN > 0 )
  187.     {
  188.         DSP_X = CUR_POS * FNT_X + TOP_X ;
  189.         wrt( (char *)&linebuf[CUR_POS],writepage, DSP_X,DSP_Y,
  190.                     col_tbl[COL_CHR],col_tbl[BAK_CHR], FSIZE ) ;
  191.         DSP_LEN = 0 ;
  192.     }
  193.     CUR_POS = CUR_X ;
  194.     CUT_POS = CUT_X ;
  195.     cur_dsp( 0 ) ;
  196. }
  197.  
  198. void    wind_close( void )
  199. {
  200.     if( OPEN != FALSE )
  201.     {
  202.         OPEN = FALSE ;
  203.         MOS_disp( MOS_OFF ) ;
  204.         cflush() ;
  205.         if( CUT_X != -1 )
  206.             cut_paste( FALSE ) ;
  207.         cur_dsp( 1 ) ;
  208.         MOS_disp( MOS_ON ) ;
  209.  
  210.         strcpy( EDITBUF, linebuf ) ;
  211.     }
  212. }
  213.  
  214.  
  215. WIND    *wind_open( int x,int y, int len,int *curpos,
  216.                                     int col, int bak,int cur, char *init )
  217. {
  218.     int     i ;
  219.  
  220.     if( OPEN != FALSE )
  221.         wind_close() ;
  222.  
  223.     KYB_clrbuf() ;
  224.     for( i = 0x8001 ; i <= 0x800B ; i ++ )  /*  PF1～PF11  */
  225.         KYB_asign( 0, i, 1, "1" ) ;
  226.     KYB_asign( 0, 0x801D, 1, "1" ) ;        /*  PF12  */
  227.     KYB_clrbuf() ;
  228.  
  229.     MOS_disp( MOS_OFF ) ;
  230.  
  231.     box2( x-2,y-2, x+len*8,y+15+2, 0,0 ) ;
  232.  
  233.     OPEN = TRUE ;
  234.     TOP_X = x ;
  235.     TOP_Y = y ;
  236.     BTM_X = x + len*8 ;
  237.     BTM_Y = y + 15 ;
  238.     SIZ_X = len + 1 ;
  239.     _CUR_X = curpos ;
  240.     CUT_X = CUT_POS = -1 ;
  241.     CUR_POS = 0 ;
  242.     COL_CHR = col ;
  243.     BAK_CHR = COL_BAK = bak ;
  244.     CUR_COL = cur ;
  245.     KAN_COD = 0 ;
  246.     DSP_X = TOP_X ;
  247.     DSP_Y = TOP_Y ;
  248.     DSP_LEN = 0 ;
  249.     EDITBUF = init ;
  250.  
  251.     mos_x = mos_y = -1 ;
  252.  
  253.     if( init == NULL )
  254.     {
  255.         linebuf[0] = '\0' ;
  256.         linelen = 0 ;
  257.         CUR_X = 0 ;
  258.     }
  259.     else
  260.     {
  261.         strcpy( linebuf, init ) ;
  262.         typecheck( ktype, linebuf, LINE_MAX ) ;
  263.         linelen = strlen( init ) ;
  264.         DSP_LEN = 1 ;
  265.         if( CUR_X > linelen )
  266.             CUR_X = linelen ;
  267.         if( ktype[CUR_X] == IS_KANJI2 )
  268.             CUR_X -- ;
  269.     }
  270.  
  271.     cur_dsp( 0 ) ;
  272.     cflush() ;
  273.  
  274.     MOS_disp( MOS_ON ) ;
  275.  
  276.     return wp ;
  277. }
  278.  
  279. static  int     ins_char( char str[] )
  280. {
  281.     REGS    int     i ;
  282.  
  283.     if( linelen >= SIZ_X-1 )
  284.         return -1 ;
  285.  
  286.     for( i = linelen ; i >= 0 ; i -- )
  287.         str[i+1] = str[i] ;
  288.     linelen ++ ;
  289.  
  290.     return 0 ;
  291. }
  292.  
  293. static  int    del_char( int pos )
  294. {
  295.     REGS    int     i, len ;
  296.  
  297.     len = ( ktype[pos] == IS_KANJI1 ) ? 2 : 1 ;
  298.  
  299.     for( i = pos ; i < linelen ; i ++ )
  300.         linebuf[i] = linebuf[i+len] ;
  301.     if( linelen > 0 )
  302.         linelen -= len ;
  303.  
  304.     return len ;
  305. }
  306.  
  307. static  void    chr_out( u_char ch )
  308. {
  309.     if( CUR_X + 1 < SIZ_X )
  310.     {
  311.         if( ins_char( (char *)&linebuf[CUR_X] ) != -1 )
  312.         {
  313.             linebuf[CUR_X ++] = ch ;
  314.             DSP_BUF[DSP_LEN++] = ch ;
  315.             typecheck( ktype, linebuf, LINE_MAX ) ;
  316.             return ;
  317.         }
  318.     }
  319.     putchar( '\x07' ) ; fflush( stdout ) ;
  320. }
  321.  
  322. static  void    key_del( void )
  323. {
  324.     int     len ;
  325.  
  326.     if( linelen <= CUR_X )
  327.         return ;
  328.     len = del_char( CUR_X ) ;
  329.     linebuf[linelen] = ' ' ;
  330.     if( len == 2 )
  331.         linebuf[linelen+1] = ' ', linebuf[linelen+2] = '\0' ;
  332.     else
  333.         linebuf[linelen+1] = '\0' ;
  334.     CUR_POS = CUR_X ;
  335.     DSP_LEN = 1 ;
  336.     cflush() ;
  337.     linebuf[linelen] = '\0' ;
  338.     typecheck( ktype, linebuf, LINE_MAX ) ;
  339. }
  340.  
  341. static  void    key_left( void )
  342. {
  343.     if( CUR_X > 0 )
  344.         CUR_X -- ;
  345.     if( CUR_X > 0 && ktype[CUR_X] == IS_KANJI2 )
  346.         CUR_X -- ;
  347. /*
  348.     if( CUR_X > 1 && ktype[CUR_X-1] == IS_KANJI2 )
  349.         CUR_X -= 2 ;
  350.     else if( CUR_X > 0 )
  351.         CUR_X -- ;
  352. */
  353. }
  354.  
  355. static  void    cut_paste( int sw )
  356. {
  357.     int     color ;
  358.  
  359.     if( sw == TRUE )    /*  開始  */
  360.     {
  361.         wrt( " 範囲指定中 ", writepage, 320,464, COL_0,COL_6, 16 ) ;
  362.         CUT_X = CUR_X ;
  363.     }
  364.     else                /*  終了  */
  365.     {
  366.         color = ( writepage == 0 ) ? 15 : 0 ;
  367.  
  368.         wrt( "            ",
  369.             writepage, 320,464, col_tbl[color],col_tbl[color], 16 ) ;
  370.  
  371.         CUT_X = -1 ;
  372.     }
  373. }
  374.  
  375. static  void    _putch( int ch )
  376. {
  377.     u_char  *p ;
  378.     int     i ;
  379.  
  380.     if( OPEN == FALSE )     /*  window がオープンしてなければパス  */
  381.         return ;
  382.  
  383.     if( ( ch & 0xFF00 ) == 0x8000 )   /*  特殊キー  */
  384.     {
  385.         switch( ch )
  386.         {
  387.           case 0x8062:    /*  PF6 : 範囲指定開始  */
  388.             if( CUT_X < 0 )
  389.                 cut_paste( TRUE ) ;
  390.             else
  391.                 cut_paste( FALSE ) ;
  392.             break ;
  393.  
  394.           case 0x8063:    /*  PF7 : カット        */
  395.             if( CUT_POS != -1 )
  396.                 if( CUT_POS < CUR_POS )             /*  指定されている  */
  397.                 {
  398.                     strncpy( cutbuf, &linebuf[CUT_POS], CUR_POS-CUT_POS ) ;
  399.                     cutbuf[CUR_POS-CUT_POS] = '\0' ;
  400.                     cut_paste( FALSE ) ;
  401.  
  402.                     CUR_X = CUT_POS ;
  403.                     for( i = 0 ; i < kstrlen( (u_char *)cutbuf ) ; i ++ )
  404.                         key_del() ;
  405.                 }
  406.                 else
  407.                     cut_paste( FALSE ) ;
  408.             break ;
  409.  
  410.           case 0x8064:    /*  PF8 : コピー        */
  411.             if( CUT_POS != -1 )
  412.             {
  413.                 if( CUT_POS < CUR_POS )             /*  指定されている  */
  414.                 {
  415.                     strncpy( cutbuf, &linebuf[CUT_POS], CUR_POS-CUT_POS ) ;
  416.                     cutbuf[CUR_POS-CUT_POS] = '\0' ;
  417.                 }
  418.                 cut_paste( FALSE ) ;
  419.             }
  420.             break ;
  421.  
  422.           case 0x8065:    /*  PF9 : ペースト      */
  423.             if( CUT_POS != -1 )
  424.             {
  425.                 cut_paste( FALSE ) ;
  426.             }
  427.             else if( strlen( cutbuf ) > 0 )
  428.             {
  429.                 for( p = (u_char *)cutbuf ; *p != '\0' ; p ++ )
  430.                     putch( *p ) ;
  431.             }
  432.             break ;
  433.         }
  434.         return ;
  435.     }
  436.     else
  437.         ch &= 0xFF ;
  438.  
  439.     switch( ch )
  440.     {
  441.       case 0x0B:    /*  CTRL-K, HOME  */
  442.         if( ( bec >> 8 ) == 0x4E )  /*  HOME  */
  443.         {
  444.             if( CUR_X > 0 )
  445.                 CUR_X = 0 ;
  446.             else
  447.                 CUR_X = linelen ;
  448.             cflush() ;
  449.         }
  450.         else                    /*  CTRL-K [行末まで削除] */
  451.         {
  452.             while( CUR_X < linelen )
  453.                 key_del() ;
  454.         }
  455.         break ;
  456.  
  457.       case 0x1D:    /*  左カーソル  */
  458.       case 0x13:    /*  ^S  */
  459.         if( ( bec & 4 ) != 0 )  /*  shift  */
  460.             CUR_X = 0 ;
  461.         else
  462.             key_left() ;
  463.         cflush() ;
  464.         break ;
  465.  
  466.       case 0x1C:    /*  右カーソル  */
  467.       case 0x04:    /*  ^D  */
  468.         if( ( bec & 4 ) != 0 )  /*  shift  */
  469.             CUR_X = linelen ;
  470.         else
  471.         {
  472.             if( CUR_X < linelen )
  473.                 CUR_X ++ ;
  474.             if( CUR_X < linelen && ktype[CUR_X] == IS_KANJI2 )
  475.                 CUR_X ++ ;
  476. /*
  477.             if( CUR_X < linelen && iskanji( linebuf[CUR_X] ) )
  478.                 CUR_X += 2 ;
  479.             else if( CUR_X < linelen )
  480.                 CUR_X ++ ;
  481. */
  482.         }
  483.         cflush() ;
  484.         break ;
  485.  
  486.       case 0x08:    /*  BS  */
  487.         if( CUR_X > 0 )
  488.         {
  489.             key_left() ;
  490.             key_del() ;
  491.         }
  492.         break ;
  493.  
  494.       case 0x15:    /*  CTRL_U [行頭まで削除]  */
  495.         while( CUR_X > 0 )
  496.         {
  497.             key_left() ;
  498.             key_del() ;
  499.         }
  500.         break ;
  501.  
  502.       case 0x7F:    /*  DEL  */
  503.       case 0x07:    /*  ^G   */
  504.         key_del() ;
  505.         break ;
  506.  
  507.       default:
  508.         if( KAN_COD != 0 )
  509.         {
  510.             if( iskanji2( ch ) )
  511.             {
  512.                 if( CUR_X == ( SIZ_X - 1 ) )
  513.                     chr_out( ' ' ) ;
  514.                 chr_out( KAN_COD ) ;
  515.                 chr_out( ch ) ;
  516.                 KAN_COD = 0 ;
  517.                 return ;
  518.             }
  519.             KAN_COD = 0 ;
  520.         }
  521.         if( iskanji( ch ) )
  522.         {
  523.             KAN_COD = ch ;
  524.             return ;
  525.         }
  526.         if( ch >= ' ' )
  527.         {
  528.             chr_out( ch ) ;
  529.             return ;
  530.         }
  531.     }
  532. }
  533.  
  534. void    putch( int ch )
  535. {
  536.     MOS_disp( MOS_OFF ) ;
  537.     if( ch == 0x1B || ch == 0x0D )
  538.         wind_close() ;
  539.     else
  540.     {
  541.         _putch( ch ) ;
  542.         cflush() ;
  543.     }
  544.     MOS_disp( mos_disp ) ;
  545. }
  546.  
  547. /*
  548. void    cputs( char *str )
  549. {
  550.     while( *str != '\0' )
  551.         putch( (unsigned char)*(str++) ) ;
  552. }
  553.  
  554. void    cprintf( char *form,... )
  555. {
  556.     va_list arg ;
  557.  
  558.     va_start( arg, form ) ;
  559.     vsprintf( tmpbuf, form, arg ) ;
  560.     cputs( tmpbuf ) ;
  561.     va_end( arg ) ;
  562. }
  563. */
  564.  
  565.  
  566. int     lineedit( int *x,int *y, int len,int *curpos,
  567.                     int forcol,int bakcol,int curcol, u_char *buf )
  568. {
  569.     int     ch ;
  570.  
  571.     mos_ptn( 6 ) ;
  572.     wind_open( *x,*y, len,curpos, forcol,bakcol,curcol, (char *)buf ) ;
  573.     KAN_putsys( 0,0, kan_mode ) ;
  574.  
  575.     while( 1 )
  576.     {
  577.         ch = getch() ;
  578.         if( ch == 0x05 )    ch = 0x1E ;
  579.         if( ch == 0x18 )    ch = 0x1F ;
  580.  
  581.         if( ch == 0x1B || ch == '\x0A' || ch == '\x0D' ||
  582.                                 ch == '\x1E' || ch == '\x1F' )
  583.             break ;
  584.  
  585.         MOS_disp( MOS_OFF ) ;
  586.         if( ch != 0xF00 )
  587.             putch( ch ) ;
  588.         cflush() ;
  589.         MOS_disp( MOS_ON ) ;
  590.     }
  591.  
  592.     wind_close() ;
  593.  
  594.     strcpy( (char *)buf, linebuf ) ;
  595.     *curpos = CUR_X ;
  596.  
  597.     if( mos_x != -1 && mos_y != -1 )
  598.         *x = mos_x, *y = mos_y ;
  599.  
  600.     return ch ;
  601. }
  602.  
  603. #ifdef SAMPLE
  604. void    main()
  605. {
  606.     auto    char    buf[ 256 ], ch ;
  607.  
  608.     EGB_init( egbwork, EgbWorkSize ) ;
  609.     EGB_resolution( egbwork, 0, 3 ) ;
  610.     EGB_displayPage( egbwork, 0, 1 ) ;
  611.  
  612.     strcpy( buf, "Initialize Data 0123456789" ) ;
  613.  
  614.     while( 1 )
  615.     {
  616.         ch = lineedit( 100,10, 60, 15,8,15, buf ) ;
  617.         if( ch == '\x1B' || ch == '\x0D' )  break ;
  618.         ch = lineedit( 100,34, 60, 15,8,15, buf ) ;
  619.         if( ch == '\x1B' || ch == '\x0D' )  break ;
  620.     }
  621.  
  622.     wrt( linebuf, writepage, 100,58, COL_15,COL_8, FSIZE ) ;
  623.     while( kbhit( ON ) == 0 ) ;
  624. }
  625. #endif
  626.  
  627.  
  628. void    KAN_start( void )
  629. {
  630.     KAN_open( KAN_putstr, KAN_putsys, KAN_putmode ) ;
  631. }
  632.  
  633. void    KAN_end( void )
  634. {
  635.     KAN_close() ;
  636. }
  637.  
  638.  
  639.  
  640. static  u_short fortbl[] =
  641. {
  642.     0x000F,0x000F,0x000F,0x000F,0x000F,0x000F,0x000F,0x000F,
  643.     0x000F,0x000F,0x000F,0x000F,0x000F,0x000F,0x000F,0x000F,
  644. } ;
  645. static  u_short baktbl[] =
  646. {
  647.     0x0000,0x0001,0x0002,0x0003,0x0004,0x0005,0x0006,0x0007,
  648.     0x0008,0x0009,0x000A,0x000B,0x000C,0x000D,0x000E,0x000F,
  649. } ;
  650.  
  651. static  void    KAN_putstr( int pos, int len, char *str, char *att )
  652. {
  653.     static  int     bak_len = 0 ;
  654.     static  char    *bak_buf[128] = "" ;
  655.     auto    int     i, x, y, n, m ;
  656.     auto    char    *p ;
  657.     auto    char    para[16] ;
  658.     auto    int     TOPx = TOP_X ;
  659.  
  660.     if( ( TOPx % 2 ) == 1 )
  661.         TOPx -- ;
  662.  
  663.     MOS_disp( MOS_OFF ) ;
  664.  
  665.     for( i = 0 ; i < bak_len ; i++ )
  666.     {
  667.         EGB_putBlock( egbwork, 0, bak_buf[i] ) ;
  668.         free( bak_buf[i] ) ;
  669.     }
  670.     cflush() ;
  671.     bak_len = 0 ;
  672.     x = CUR_X ;     y = 0 ;
  673.     if( ( m = len ) > 0 && len == pos )
  674.         m ++ ;
  675.  
  676.     for( i = 0 ; i < m ; i += n )
  677.     {
  678.         n = ( ( i < len && iskanji( (u_char)*str ) ) ? 2:1 ) ;
  679.  
  680. #if 0
  681.         if( ( x + n ) > SIZ_X )
  682. #else
  683.         if( ( ( x + n ) * 8 + TOPx ) > 638 )
  684. #endif
  685.         {
  686.             x = 0 ;
  687.             y ++ ;
  688.         }
  689.  
  690.         if ( (p = (char *)malloc(FNT_X * FNT_Y * n * PIX_BYTE + 14)) == NULL )
  691.             break ;
  692.  
  693.         DWORD(p+0) = (unsigned int)(p+14) ;
  694.         WORD(p+4) = 0x014 ;                      /* Data Selecter */
  695.         WORD(p+6) = TOPx + x * FNT_X ;
  696.         WORD(p+8) = TOP_Y + y * FNT_Y ;
  697.         WORD(p+10) = WORD(p+6) + n * FNT_X - 1 ;
  698.         WORD(p+12) = WORD(p+8) + FNT_Y - 1 ;
  699.         EGB_getBlock( egbwork, p ) ;
  700.         bak_buf[bak_len++] = p ;
  701.  
  702.         if( i < len )
  703.         {
  704.             para[0] = *str ;
  705.             if( n == 2 )
  706.                 para[1] = *(str+1), para[2] = '\0' ;
  707.             else
  708.                 para[1] = '\0' ;
  709.             wrt( para, writepage, WORD(p+6),WORD(p+8),
  710.                 col_tbl[fortbl[*att]], col_tbl[baktbl[*att]], FSIZE ) ;
  711.             str += n ;
  712.             att += n ;
  713.         }
  714.  
  715.         if( i == pos )
  716.         {
  717.             EGB_writeMode( egbwork, MODE_XOR ) ;
  718.             EGB_paintMode( egbwork, 0x022 ) ;
  719.             EGB_color( egbwork, 0, CUR_COL ) ;
  720.             WORD(para+0) = WORD(p+6);
  721.             WORD(para+2) = WORD(p+8);
  722.             WORD(para+4) = WORD(p+10);
  723.             WORD(para+6) = WORD(p+12);
  724.             EGB_rectangle( egbwork, para ) ;
  725.             EGB_writeMode( egbwork, MODE_PSET ) ;
  726.         }
  727. #if 0
  728.         if( ( x += n ) >= SIZ_X )
  729. #else
  730.         x += n ;
  731.         if( ( x * 8 + TOPx ) >= 638 )
  732. #endif
  733.         {
  734.             x = 0 ;
  735.             y ++ ;
  736.         }
  737.     }
  738.  
  739.     MOS_disp( MOS_ON ) ;
  740. }
  741.  
  742. static  void    KAN_putsys( int len, char *str, char *att )
  743. {
  744.     static  int     bak_len = 0 ;
  745.     static  char    *bak_buf = "" ;
  746.     auto    int     i, x, y, n ;
  747.     auto    char    *p ;
  748.  
  749.     MOS_disp( MOS_OFF ) ;
  750.  
  751.     if( bak_len > 0 )
  752.     {
  753.         EGB_putBlock( egbwork, 0, bak_buf ) ;
  754.         free( bak_buf ) ;
  755.     }
  756.  
  757.     bak_len = 0 ;
  758.     if( len == 0 )
  759.     {
  760.         MOS_disp( MOS_ON ) ;
  761.  
  762.         return ;
  763.     }
  764.  
  765.     if( ( p = bak_buf = 
  766.          (char *)malloc(FNT_X * FNT_Y * len * PIX_BYTE + 14)) == NULL )
  767.     {
  768.         MOS_disp( MOS_ON ) ;
  769.         return ;
  770.     }
  771.  
  772.     DWORD(p+0) = (u_int)(p+14) ;
  773.     WORD(p+4) = 0x014 ;                  /* Data Selecter */
  774.     WORD(p+6) = x = TOP_X ;
  775.     WORD(p+8) = y = BTM_Y + 8 ;
  776.     WORD(p+10) = x + len * FNT_X - 1 ;
  777.     WORD(p+12) = y + FNT_Y - 1 ;
  778.     EGB_getBlock( egbwork, p ) ;
  779.     bak_len = len ;
  780.  
  781.     for( i = 0 ; i < len ; i += n )
  782.     {
  783.         n = (iskanji((unsigned char)*str) ? 2:1);
  784.  
  785.         tmpbuf[0] = *str ;
  786.         tmpbuf[1] = *(str+1) ;
  787.         tmpbuf[2] = '\0' ;
  788.  
  789.         wrt( tmpbuf, writepage, x,y,
  790.                 col_tbl[fortbl[*att]], col_tbl[baktbl[*att]], FSIZE ) ;
  791.         str += n ;
  792.         att += n ;
  793.         x += ( FNT_X * n ) ;
  794.     }
  795.  
  796.     MOS_disp( MOS_ON ) ;
  797. }
  798.  
  799. static  void    KAN_putmode( int mode, int shift_status, char *str )
  800. {
  801. #define MODE_X 560
  802. #define MODE_Y 460
  803.     mode = mode, shift_status = shift_status ;  /*  Warnings 回避  */
  804.  
  805.     MOS_disp( MOS_OFF ) ;
  806.  
  807.     strcpy( kan_mode, str ) ;
  808.     KAN_dispMode() ;
  809.  
  810.     MOS_disp( MOS_ON ) ;
  811. }
  812.  
  813. void    KAN_dispMode( void )        /*  モードを再表示  */
  814. {
  815.     EGB_paintMode( egbwork, 0x22 ) ;
  816.     EGB_color( egbwork, 0, COL_CHR ) ;
  817.     EGB_color( egbwork, 2, COL_BAK ) ;
  818.     WORD(tmpbuf+0) = MODE_X - 2 ;
  819.     WORD(tmpbuf+2) = MODE_Y - 2 ;
  820.     WORD(tmpbuf+4) = MODE_X + 72 + 1 ;
  821.     WORD(tmpbuf+6) = MODE_Y + 16 + 1 ;
  822.     EGB_rectangle( egbwork, tmpbuf ) ;
  823.  
  824.     wrt( kan_mode, writepage,MODE_X,MODE_Y,
  825.                         col_tbl[COL_CHR],col_tbl[COL_BAK], FSIZE ) ;
  826. }
  827.  
  828.